home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xpaint-2.1.1 / fontSelect.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  23.6 KB  |  921 lines
  1. /* +-------------------------------------------------------------------+ */
  2. /* | Copyright 1992, 1993, David Koblas (koblas@netcom.com)            | */
  3. /* |                                                                   | */
  4. /* | Permission to use, copy, modify, and to distribute this software  | */
  5. /* | and its documentation for any purpose is hereby granted without   | */
  6. /* | fee, provided that the above copyright notice appear in all       | */
  7. /* | copies and that both that copyright notice and this permission    | */
  8. /* | notice appear in supporting documentation.  There is no           | */
  9. /* | representations about the suitability of this software for        | */
  10. /* | any purpose.  this software is provided "as is" without express   | */
  11. /* | or implied warranty.                                              | */
  12. /* |                                                                   | */
  13. /* +-------------------------------------------------------------------+ */
  14.  
  15. #include <X11/StringDefs.h>
  16. #include <X11/Intrinsic.h>
  17. #include <X11/Shell.h>
  18. #include <X11/Xaw/Form.h>
  19. #include <X11/Xaw/Paned.h>
  20. #include <X11/Xaw/List.h>
  21. #include <X11/Xaw/AsciiText.h>
  22. #include <X11/Xaw/Command.h>
  23. #include <X11/Xaw/Viewport.h>
  24. #include <X11/Xos.h>
  25. #include <math.h>
  26. #include <stdio.h>
  27.  
  28. /*
  29. **  swiped from X11/Xfuncproto.h
  30. **   since qsort() may or may not be defined with a constant sub-function
  31. */
  32. #ifndef _Xconst
  33. #if __STDC__ || defined(__cplusplus) || defined(c_plusplus) || (FUNCPROTO&4)
  34. #define _Xconst const
  35. #else
  36. #define _Xconst
  37. #endif
  38. #endif /* _Xconst */
  39.  
  40. #ifndef NOSTDHDRS
  41. #include <stdlib.h>
  42. #include <unistd.h>
  43. #endif
  44.  
  45. #include "xpaint.h"
  46. #include "misc.h"
  47. #include "ops.h"
  48.  
  49. typedef struct {
  50.     char    *fontFamily;
  51.     char    *registry;
  52.     char    *foundry;
  53.     char    *weight;
  54.     char    *slant;
  55.     char    *setWidth;
  56.     char    *points;
  57.     char    *spacing;
  58.     Boolean    forcePoint;
  59. } FontName;
  60.  
  61. static Boolean    haveScalable = False;
  62.  
  63. typedef struct StringList_s {
  64.     char            *str;
  65.     struct StringList_s    *next;
  66. } StringList;
  67.  
  68. typedef struct {
  69.     int        number;
  70.     FontName    *names;
  71.     char        **namesStorage;
  72.     Widget        text, paint;
  73.     Widget        family, weight, point, spacing;
  74.     Widget        expect, pointSelect;
  75.     Widget        fontName;
  76.     Boolean        expectFlag;
  77. } arg_t;
  78.  
  79.  
  80. static struct shortFamily_s {
  81.     char    *name;
  82.     char    *family, *registry, *foundry;
  83. } shortFamily[128];
  84. static int shortFamilyNum = 0;
  85.  
  86. static arg_t    *theArg = NULL;
  87.  
  88. static char    *getShortFamily(char *family, char *foundry, char *registry)
  89. {
  90.     int    i;
  91.  
  92.     for (i = 0; i < shortFamilyNum; i++) {
  93.         if (strcmp(shortFamily[i].family, family) == 0 &&
  94.             strcmp(shortFamily[i].foundry, foundry) == 0 &&
  95.             strcmp(shortFamily[i].registry, registry) == 0)
  96.             return shortFamily[i].name;
  97.     }
  98.     return "UNKNOWN";
  99. }
  100.  
  101. static void    makeShortFamily(char *family, char *foundry, char *registry)
  102. {
  103.     char    buf[256];
  104.  
  105.     if (strcmp(getShortFamily(family, foundry, registry), "UNKNOWN") != 0)
  106.         return;
  107.     
  108.     shortFamily[shortFamilyNum].family   = family;
  109.     shortFamily[shortFamilyNum].foundry  = foundry;
  110.     shortFamily[shortFamilyNum].registry = registry;
  111.     sprintf(buf, "%s (%s,%s)", family, foundry, registry);
  112.     shortFamily[shortFamilyNum].name     = XtNewString(buf);
  113.     shortFamilyNum++;
  114. }
  115.  
  116. static struct shortSizes_s {
  117.     char    *name;
  118.     char    *weight;
  119.     char    *slant;
  120.     char    *setWidth;
  121.     char    *serif;
  122. } shortSizes[128];
  123. static int shortSizesNum = 0;
  124.  
  125. static char    *getShortName(char *weight, char *slant, char *setWidth, char *serif)
  126. {
  127.     int    i;
  128.     for (i = 0; i < shortSizesNum; i++) {
  129.         if (strcmp(shortSizes[i].weight, weight) == 0 &&
  130.             strcmp(shortSizes[i].slant, slant) == 0 &&
  131.             strcmp(shortSizes[i].setWidth, setWidth) == 0 &&
  132.             strcmp(shortSizes[i].serif, serif) == 0)
  133.             return shortSizes[i].name;
  134.     }
  135.     return "UNKNOWN";
  136. }
  137.  
  138. static void    makeShortName(char *weight, char *slant, char *setWidth, char *serif)
  139. {
  140.     char     *weStr, *slStr, *swStr, *seStr;
  141.     char    *cp, buf[128];
  142.  
  143.     if (strcmp(getShortName(weight, slant, setWidth, serif), "UNKNOWN") != 0)
  144.         return;
  145.  
  146.     shortSizes[shortSizesNum].weight = weight;
  147.     shortSizes[shortSizesNum].slant = slant;
  148.     shortSizes[shortSizesNum].setWidth = setWidth;
  149.     shortSizes[shortSizesNum].serif = serif;
  150.  
  151.     if (*weight == '\0')
  152.         weStr = NULL;
  153.     else if (strcmp(weight, "medium") == 0)
  154.         weStr = "";
  155.     else if (strcmp(weight, "bold") == 0)
  156.         weStr = "Bold";
  157.     else
  158.         weStr = weight;
  159.     
  160.     if (*slant == '\0')
  161.         slStr = NULL;
  162.     else if (*slant == 'r')
  163.         slStr = "";
  164.     else if (*slant == 'i')
  165.         slStr = "Italic";
  166.     else if (*slant == 'o')
  167.         slStr = "Oblique";
  168.     else
  169.         slStr = slant;
  170.  
  171.     if (*setWidth == '\0')
  172.         swStr = NULL;
  173.     else if (strcmp(setWidth, "normal") == 0)
  174.         swStr = "";
  175.     else if (strcmp(setWidth, "semicondensed") == 0)
  176.         swStr = "Condensed";
  177.     else
  178.         swStr = setWidth;
  179.  
  180.     if (*serif == '\0')
  181.         seStr = NULL;
  182.     else if (strcmp(serif, "sans") == 0)
  183.         seStr = "";
  184.     else
  185.         seStr = serif;
  186.  
  187.     if (weStr == NULL && slStr == NULL && swStr == NULL && seStr == NULL) {
  188.         shortSizes[shortSizesNum++].name = "Unspecified";
  189.         return;
  190.     }
  191.     if (weStr == NULL) weStr = "";
  192.     if (slStr == NULL) slStr = "";
  193.     if (swStr == NULL) swStr = "";
  194.     if (seStr == NULL) seStr = "";
  195.  
  196.     if (*weStr == '\0' && *slStr == '\0' && *swStr == '\0' && *seStr == '\0') {
  197.         shortSizes[shortSizesNum++].name = "Normal";
  198.         return;
  199.     }
  200.  
  201.     /*
  202.     ** Make the string, eat the leading and trailing white space.
  203.     */
  204.     sprintf(buf, "%s %s %s %s", weStr, slStr, swStr, seStr);
  205.     for (cp = buf + strlen(buf) - 1; *cp == ' '; cp--)
  206.         ;
  207.     *++cp = '\0';
  208.     for (cp = buf; *cp == ' '; cp++)
  209.         ;
  210.     shortSizes[shortSizesNum++].name = XtNewString(cp);
  211. }
  212.  
  213. static FontName    *getSettings(arg_t *arg)
  214. {
  215.     static char        pointBuf[20];
  216.     static FontName        name;
  217.     XawListReturnStruct    *item;
  218.     int            i;
  219.  
  220.     name.fontFamily = NULL;
  221.     name.weight     = NULL;
  222.     name.slant      = NULL;
  223.     name.setWidth   = NULL;
  224.     name.points     = NULL;
  225.     name.spacing    = NULL;
  226.     name.foundry    = NULL;
  227.     name.registry   = NULL;
  228.     name.forcePoint = False;
  229.  
  230.     if ((item = XawListShowCurrent(arg->family))->list_index != XAW_LIST_NONE) {
  231.         for (i = 0; i < XtNumber(shortFamily); i++) {
  232.             if (strcmp(item->string, shortFamily[i].name) == 0) {
  233.                 name.fontFamily = shortFamily[i].family;
  234.                 name.registry = shortFamily[i].registry;
  235.                 name.foundry = shortFamily[i].foundry;
  236.                 break;
  237.             }
  238.         }
  239.         XtFree((XtPointer)item);
  240.     }
  241.     if ((item = XawListShowCurrent(arg->point))->list_index != XAW_LIST_NONE) {
  242.         float    ps = atof(item->string);
  243.         if (ps < 0.1 && haveScalable) {
  244.             String    str;
  245.             name.forcePoint = True;
  246.             XtVaGetValues(arg->pointSelect, XtNstring, &str, NULL);
  247.             ps = atof(str);
  248.             if (ps < 0.1) {
  249.                 ps = 12.0;
  250.                 XtVaSetValues(arg->pointSelect, XtNstring, "12", NULL);
  251.             }
  252.         }
  253.         sprintf(pointBuf,"%d",(int)(ps * 10.0));
  254.         name.points = pointBuf;
  255.         XtFree((XtPointer)item);
  256.     }
  257.     if ((item = XawListShowCurrent(arg->weight))->list_index != XAW_LIST_NONE) {
  258.         for (i = 0; i < XtNumber(shortSizes); i++) {
  259.             if (strcmp(item->string, shortSizes[i].name) == 0) {
  260.                 name.weight = shortSizes[i].weight;
  261.                 name.slant = shortSizes[i].slant;
  262.                 name.setWidth = shortSizes[i].setWidth;
  263.                 break;
  264.             }
  265.         }
  266.         XtFree((XtPointer)item);
  267.     }
  268.     if ((item = XawListShowCurrent(arg->spacing))->list_index != XAW_LIST_NONE) {
  269.         if (strcmp(item->string, "Fixed") == 0)
  270.             name.spacing = "m";
  271.         else if (strcmp(item->string, "Variable") == 0)
  272.             name.spacing = "p";
  273.         else if (strcmp(item->string, "Cell") == 0)
  274.             name.spacing = "c";
  275.         else
  276.             name.spacing = item->string;
  277.         XtFree((XtPointer)item);
  278.     }
  279.  
  280.     return &name;
  281. }
  282.  
  283. static int strqsortcmp(char **a, char **b)
  284. { 
  285.     return strcmp(*a, *b);
  286. }
  287.  
  288. static int valqsortcmp(char **a, char **b)
  289. { 
  290.     float    fa = atof(*a);
  291.     float    fb = atof(*b);
  292.     if (fa == fb)
  293.         return 0;
  294.     if (fa < fb)
  295.         return -1;
  296.     return 1;
  297. }
  298.  
  299. static void cleanLists(arg_t *arg)
  300. {
  301.     String    *strs;
  302.     int    num;
  303.  
  304.     XtVaGetValues(arg->spacing, XtNnumberStrings, &num, XtNlist, &strs, NULL);
  305.     if (strs != NULL && num != 0) XtFree((XtPointer)strs);
  306.     XtVaGetValues(arg->family, XtNnumberStrings, &num, XtNlist, &strs, NULL);
  307.     if (strs != NULL && num != 0) XtFree((XtPointer)strs);
  308.     XtVaGetValues(arg->weight, XtNnumberStrings, &num, XtNlist, &strs, NULL);
  309.     if (strs != NULL && num != 0) XtFree((XtPointer)strs);
  310.     XtVaGetValues(arg->point, XtNnumberStrings, &num, XtNlist, &strs, NULL);
  311.     if (strs != NULL && num != 0) {
  312.         int    i;
  313.         for (i = 0; i < num; i++)
  314.             XtFree((XtPointer)strs[i]);
  315.         XtFree((XtPointer)strs);
  316.     }
  317. }
  318.  
  319. static void    match(arg_t *arg)
  320. {
  321.     static int    firstTime = True;
  322.     int        i;
  323.     int        count = 0;
  324.     char        *nm;
  325.     FontName    *cur = arg->names, *last = NULL;
  326.     FontName    *set = getSettings(arg);
  327.     StringList    *familyList = NULL, *pointList = NULL;
  328.     StringList    *weightList = NULL, *spacingList = NULL;
  329.     int        familyListLen = 0, pointListLen = 0;
  330.     int        weightListLen = 0, spacingListLen = 0;
  331.     StringList    *curStr, *nxtStr;
  332.     String        *list;
  333.  
  334.     if (firstTime)
  335.         firstTime = False;
  336.     else
  337.         cleanLists(arg);
  338.  
  339.     for (i = 0; i < arg->number; i++, cur++) {
  340.  
  341. #define TEST(f)    if (set->f != NULL && strcmp(set->f, cur->f) != 0) continue
  342.         TEST(fontFamily);
  343.         TEST(foundry);
  344.         TEST(registry);
  345.         TEST(weight);
  346.         TEST(slant);
  347.         TEST(setWidth);
  348.         if (set->forcePoint) {
  349.             if (strcmp(cur->points, "0") != 0) continue;
  350.         } else {
  351.             TEST(points);
  352.         }
  353.         TEST(spacing);
  354. #undef TEST
  355.  
  356.         /*
  357.         **  Add the family name
  358.         */
  359.         switch (*cur->spacing) {
  360.         case 'm': nm = "Fixed";        break;
  361.         case 'p': nm = "Variable";    break;
  362.         case 'c': nm = "Cell";        break;
  363.         default:  nm = cur->spacing;    break;
  364.         }
  365.         for (curStr = spacingList; curStr != NULL; curStr = curStr->next) {
  366.             if (strcmp(curStr->str, nm) == 0)
  367.                 break;
  368.         }
  369.         if (curStr == NULL) {
  370.             curStr = XtNew(StringList);
  371.             curStr->next = spacingList;
  372.             curStr->str = nm;
  373.             spacingList = curStr;
  374.             spacingListLen++;
  375.         }
  376.  
  377.         /*
  378.         **  Add the family name
  379.         */
  380.         nm = getShortFamily(cur->fontFamily, cur->foundry, cur->registry);
  381.         for (curStr = familyList; curStr != NULL; curStr = curStr->next) {
  382.             if (strcmp(curStr->str, nm) == 0)
  383.                 break;
  384.         }
  385.         if (curStr == NULL) {
  386.             curStr = XtNew(StringList);
  387.             curStr->next = familyList;
  388.             curStr->str = nm;
  389.             familyList = curStr;
  390.             familyListLen++;
  391.         }
  392.  
  393.         /*
  394.         **  Add the width info
  395.         */
  396.         nm = getShortName(cur->weight, cur->slant, cur->setWidth, "");
  397.         for (curStr = weightList; curStr != NULL; curStr = curStr->next) {
  398.             if (strcmp(curStr->str, nm) == 0)
  399.                 break;
  400.         }
  401.         if (curStr == NULL) {
  402.             curStr = XtNew(StringList);
  403.             curStr->next = weightList;
  404.             curStr->str = nm;
  405.             weightList = curStr;
  406.             weightListLen++;
  407.         }
  408.  
  409.         /*
  410.         **  Add the point size
  411.         */
  412.         for (curStr = pointList; curStr != NULL; curStr = curStr->next) {
  413.             if ((int)(atof(curStr->str)*10.0) == atoi(cur->points)) 
  414.                 break;
  415.         }
  416.         if (curStr == NULL) {
  417.             char    buf[14];
  418.             int    p = atoi(cur->points);
  419.  
  420.             curStr = XtNew(StringList);
  421.             curStr->next = pointList;
  422.             if (p % 10 == 0) {
  423.                 sprintf(buf,"%d   ", p / 10);
  424.             } else {
  425.                 sprintf(buf,"%d.%d   ", p / 10, p % 10);
  426.             }
  427.             curStr->str = XtNewString(buf);
  428.             pointList = curStr;
  429.             pointListLen++;
  430.         }
  431.  
  432.         count++;
  433.         last = cur;
  434.     }
  435.  
  436.     if (count == 1 && last != NULL) {
  437.         char        buf[512];
  438.         XFontStruct    *info;
  439.         sprintf(buf, "-%s-%s-%s-%s-%s-*-*-%s-*-*-%s-*-%s-*",
  440.                 last->foundry,
  441.                 last->fontFamily,
  442.                 last->weight == NULL ? "" : last->weight,
  443.                 last->slant == NULL ? "" : last->slant,
  444.                 last->setWidth == NULL ? "" : last->setWidth,
  445.                 set->forcePoint ? set->points : last->points,
  446.                 last->spacing,
  447.                 last->registry);
  448.  
  449.         if ((info = XLoadQueryFont(XtDisplay(arg->text), buf)) != NULL) {
  450.             XtVaSetValues(arg->text, 
  451.                 XtNfont, info,
  452.                 XtNstring, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijlmnopqrstuvwxyz0123456789", 
  453.                 NULL);
  454.             XtVaSetValues(arg->fontName, XtNstring, buf, NULL);
  455.         }
  456.     } else {
  457.         XtVaSetValues(arg->text, XtNstring, "", NULL);
  458.         XtVaSetValues(arg->fontName, XtNstring, "", NULL);
  459.     }
  460.  
  461.     /*
  462.     **  Set the widgets
  463.     */
  464.  
  465.     list = (String *)XtCalloc(spacingListLen + 1, sizeof(String));
  466.     for (i = 0, curStr = spacingList; curStr != NULL; curStr = curStr->next, i++) 
  467.         list[i] = curStr->str;
  468.     qsort(list, i, sizeof(String), (int (*)(_Xconst void *,_Xconst void *))strqsortcmp);
  469.     XawListChange(arg->spacing, list, spacingListLen, 0, True);
  470.     if (set->spacing)
  471.         XawListHighlight(arg->spacing, 0);
  472.  
  473.     list = (String *)XtCalloc(familyListLen + 1, sizeof(String));
  474.     for (i = 0, curStr = familyList; curStr != NULL; curStr = curStr->next, i++) 
  475.         list[i] = curStr->str;
  476.     qsort(list, i, sizeof(String), (int (*)(_Xconst void *,_Xconst void *))strqsortcmp);
  477.     XawListChange(arg->family, list, familyListLen, 0, True);
  478.     if (set->fontFamily)
  479.         XawListHighlight(arg->family, 0);
  480.     
  481.     list = (String *)XtCalloc(weightListLen + 1, sizeof(String));
  482.     for (i = 0, curStr = weightList; curStr != NULL; curStr = curStr->next, i++) 
  483.         list[i] = curStr->str;
  484.     qsort(list, i, sizeof(String), (int (*)(_Xconst void *,_Xconst void *))strqsortcmp);
  485.     XawListChange(arg->weight, list, weightListLen, 0, True);
  486.     if (set->weight)
  487.         XawListHighlight(arg->weight, 0);
  488.  
  489.     list = (String *)XtCalloc(pointListLen + 1, sizeof(String));
  490.     for (i = 0, curStr = pointList; curStr != NULL; curStr = curStr->next, i++) 
  491.         list[i] = curStr->str;
  492.     qsort(list, i, sizeof(String), (int (*)(_Xconst void *,_Xconst void *))valqsortcmp);
  493.     XawListChange(arg->point, list, pointListLen, 0, True);
  494.     if (set->points)
  495.         XawListHighlight(arg->point, 0);
  496.  
  497.     /*
  498.     **  Clean up
  499.     */
  500.     for (curStr = spacingList; curStr != NULL; curStr = nxtStr) {
  501.         nxtStr = curStr->next;
  502.         XtFree((XtPointer)curStr);
  503.     }
  504.     for (curStr = familyList; curStr != NULL; curStr = nxtStr) {
  505.         nxtStr = curStr->next;
  506.         XtFree((XtPointer)curStr);
  507.     }
  508.     for (curStr = weightList; curStr != NULL; curStr = nxtStr) {
  509.         nxtStr = curStr->next;
  510.         XtFree((XtPointer)curStr);
  511.     }
  512.     for (curStr = pointList; curStr != NULL; curStr = nxtStr) {
  513.         nxtStr = curStr->next;
  514.         XtFree((XtPointer)curStr);
  515.     }
  516. }
  517.  
  518. static FontName    *chop(int *number, char **names)
  519. {
  520.     int        i, j, count = 0;
  521.     FontName    *n = (FontName*)XtCalloc(*number, sizeof(FontName));
  522.  
  523.     if (n == NULL)
  524.         return NULL;
  525.  
  526. #define NEXT(p) {     char    *np;                \
  527.             if ((np = strchr(p, '-')) == NULL)    \
  528.                 continue;            \
  529.             *np++ = '\0';                \
  530.             p = np;                    \
  531.         }
  532.  
  533.     for (i = 0; i < *number; i++) {
  534.         char        *cp = names[i];
  535.         FontName    *cur = &n[count];
  536.  
  537.         NEXT(cp);    /* foundry */
  538.         cur->foundry = cp;
  539.         NEXT(cp);    /* font family */
  540.         cur->fontFamily = cp;
  541.         NEXT(cp);    /* weight */
  542.         cur->weight = cp;
  543.         NEXT(cp);    /* slant */
  544.         cur->slant = cp;
  545.         NEXT(cp);    /* set width */
  546.         cur->setWidth = cp;
  547.         NEXT(cp);    /* NULL */
  548.         NEXT(cp);    /* pixels */
  549.         NEXT(cp);    /* point size */
  550.         cur->points = cp;
  551.         NEXT(cp);    /* horizontal resolution */
  552.         NEXT(cp);    /* vertical resolution */
  553.         NEXT(cp);    /* spacing */
  554.         cur->spacing = cp;
  555.         NEXT(cp);    /* average width */
  556.         NEXT(cp);    /* character set */
  557.         cur->registry = cp;
  558.         NEXT(cp);    /* character class */
  559.  
  560.         /*
  561.         **  Check to make sure that this is a unique font
  562.         **   from the rest of the set.
  563.         */
  564.         for (j = 0; j < count; j++) {
  565.             if (strcmp(cur->fontFamily, n[j].fontFamily) == 0 && 
  566.                 strcmp(cur->weight, n[j].weight) == 0 && 
  567.                 strcmp(cur->slant, n[j].slant) == 0 && 
  568.                 strcmp(cur->setWidth, n[j].setWidth) == 0 && 
  569.                 strcmp(cur->points, n[j].points) == 0 && 
  570.                 strcmp(cur->spacing, n[j].spacing) == 0)
  571.                 break;
  572.         }
  573.         makeShortName(cur->weight, cur->slant, cur->setWidth, "");
  574.         makeShortFamily(cur->fontFamily, cur->foundry, cur->registry);
  575.         if (j != count)
  576.             continue;
  577.         if (atoi(cur->points) == 0)
  578.             haveScalable = True;
  579.         count++;
  580.     }
  581. #undef NEXT
  582.  
  583.     *number = count;
  584.     return n;
  585. }
  586.  
  587. static void applySetCallback(Widget paint, Arg *xarg)
  588. {
  589.     XtSetValues(paint, xarg, 1);
  590.     FontChanged(paint);
  591. }
  592. static void applyCallback(Widget w, XtPointer argArg, XtPointer junk)
  593. {
  594.     arg_t        *arg = (arg_t *)argArg;
  595.     XFontStruct     *info;
  596.     Arg        xarg;
  597.  
  598.     XtVaGetValues(arg->text, XtNfont, &info, NULL);
  599.  
  600.     XtSetArg(xarg, XtNfont, info);
  601.     OperationAddArg(xarg);
  602.     GraphicAll((GraphicAllProc)applySetCallback, (void*)&xarg);
  603. }
  604. static void closeCallback(Widget w, XtPointer argArg, XtPointer junk)
  605. {
  606.     arg_t    *arg = (arg_t *)argArg;
  607.  
  608.     XtPopdown(GetShell(arg->family));
  609. }
  610. static void okCallback(Widget w, XtPointer argArg, XtPointer junk)
  611. {
  612.     applyCallback(w, argArg, junk);
  613.     closeCallback(w, argArg, junk);
  614. }
  615. static void listCallback(Widget w, XtPointer argArg, XtPointer junk)
  616. {
  617.     arg_t    *arg = (arg_t *)argArg;
  618.     arg->expectFlag = True;
  619.     arg->expect = None;
  620.     match(arg);
  621. }
  622. static void expectCallback(Widget w, XtPointer argArg, XEvent *event, Boolean *junk)
  623. {
  624.     arg_t    *arg = (arg_t*)argArg;
  625.  
  626.     if (event->type == ButtonRelease) {
  627.         if (arg->expect != None)
  628.             match(arg);
  629.         arg->expect = None;
  630.         arg->expectFlag = False;
  631.     } else if (arg->expectFlag == False) {
  632.         arg->expect = w;
  633.     }
  634. }
  635. static void pointSizeAction(Widget w, XEvent *event, String *prms, Cardinal *nprms)
  636. {
  637.     /* XXX */    
  638.     if (theArg == NULL)
  639.         return;
  640.  
  641.     if (!XtIsManaged(theArg->pointSelect))
  642.         return;
  643.     match(theArg);
  644. }
  645.  
  646. void FontSelect(Widget w, Widget paint)
  647. {
  648.     static XtActionsRec    pointAct = { "point-size-ok", (XtActionProc)pointSizeAction };
  649.     static Widget    shell = None;
  650.     Widget        pane, form, selectLabel, form2;
  651.     Widget        applyButton, okButton, doneButton, vport, label;
  652.     arg_t        *arg = XtNew(arg_t);
  653.  
  654.     if (shell != None) {
  655.         XtPopup(shell, XtGrabNone);
  656.         XMapRaised(XtDisplay(shell), XtWindow(shell));
  657.         return;
  658.     }
  659.  
  660.     StateSetBusyWatch(True);
  661.  
  662.     shell = XtVaCreatePopupShell("fontSelect",
  663.             topLevelShellWidgetClass, GetToplevel(w),
  664.             NULL);
  665.  
  666.     pane = XtVaCreateManagedWidget("pane",
  667.             panedWidgetClass, shell,
  668.             XtNborderWidth, 0,
  669.             NULL);
  670.  
  671.     label = XtVaCreateManagedWidget("title",
  672.             labelWidgetClass, pane,
  673.             XtNlabel, "Select the font properties you wish",
  674.             XtNborderWidth, 0,
  675.             XtNshowGrip, False,
  676.             NULL);
  677.  
  678.     form = XtVaCreateManagedWidget("form",
  679.             formWidgetClass, pane,
  680.             XtNborderWidth, 0,
  681.             NULL);
  682.  
  683.     /*
  684.     **  lists of items to select
  685.     */
  686.     label = XtVaCreateManagedWidget("spacingLabel",
  687.             labelWidgetClass, form,
  688.             XtNborderWidth, 0,
  689.             XtNtop, XtChainTop,
  690.             XtNbottom, XtChainTop,
  691.             NULL);
  692.     vport = XtVaCreateManagedWidget("vport",
  693.             viewportWidgetClass, form,
  694.             XtNuseBottom, True,
  695.             XtNuseRight, True,
  696.             XtNforceBars, True,
  697.             XtNallowHoriz, False,
  698.             XtNallowVert, True,
  699.             XtNfromVert, label,
  700.             XtNtop, XtChainTop,
  701.             NULL);
  702.     arg->spacing = XtVaCreateManagedWidget("spacing",
  703.                 listWidgetClass, vport,
  704.                 XtNverticalList, True,
  705.                 XtNforceColumns, True,
  706.                 XtNdefaultColumns, 1,
  707.                 XtNnumberStrings, 0,
  708.                 NULL);
  709.     label = XtVaCreateManagedWidget("familyLabel",
  710.             labelWidgetClass, form,
  711.             XtNborderWidth, 0,
  712.             XtNfromHoriz, vport,
  713.             XtNtop, XtChainTop,
  714.             XtNbottom, XtChainTop,
  715.             NULL);
  716.     vport = XtVaCreateManagedWidget("vport",
  717.             viewportWidgetClass, form,
  718.             XtNuseBottom, True,
  719.             XtNuseRight, True,
  720.             XtNforceBars, True,
  721.             XtNallowHoriz, False,
  722.             XtNallowVert, True,
  723.             XtNfromVert, label,
  724.             XtNfromHoriz, vport,
  725.             XtNtop, XtChainTop,
  726.             NULL);
  727.     arg->family = XtVaCreateManagedWidget("font",
  728.                 listWidgetClass, vport,
  729.                 XtNverticalList, True,
  730.                 XtNforceColumns, True,
  731.                 XtNdefaultColumns, 1,
  732.                 XtNnumberStrings, 0,
  733.                 NULL);
  734.     label = XtVaCreateManagedWidget("weightLabel",
  735.             labelWidgetClass, form,
  736.             XtNborderWidth, 0,
  737.             XtNfromHoriz, vport,
  738.             XtNtop, XtChainTop,
  739.             XtNbottom, XtChainTop,
  740.             NULL);
  741.     vport = XtVaCreateManagedWidget("vport",
  742.             viewportWidgetClass, form,
  743.             XtNuseBottom, True,
  744.             XtNuseRight, True,
  745.             XtNforceBars, True,
  746.             XtNallowHoriz, False,
  747.             XtNallowVert, True,
  748.             XtNfromHoriz, vport,
  749.             XtNfromVert, label,
  750.             XtNtop, XtChainTop,
  751.             NULL);
  752.     arg->weight = XtVaCreateManagedWidget("weight",
  753.                 listWidgetClass, vport,
  754.                 XtNverticalList, True,
  755.                 XtNforceColumns, True,
  756.                 XtNdefaultColumns, 1,
  757.                 XtNnumberStrings, 0,
  758.                 NULL);
  759.     label = XtVaCreateManagedWidget("pointLabel",
  760.             labelWidgetClass, form,
  761.             XtNborderWidth, 0,
  762.             XtNfromHoriz, vport,
  763.             XtNtop, XtChainTop,
  764.             XtNbottom, XtChainTop,
  765.             NULL);
  766.     vport = XtVaCreateManagedWidget("vport",
  767.             viewportWidgetClass, form,
  768.             XtNuseBottom, True,
  769.             XtNuseRight, True,
  770.             XtNforceBars, True,
  771.             XtNallowHoriz, False,
  772.             XtNallowVert, True,
  773.             XtNfromHoriz, vport,
  774.             XtNfromVert, label,
  775.             XtNtop, XtChainTop,
  776.             NULL);
  777.     arg->point = XtVaCreateManagedWidget("point",
  778.                 listWidgetClass, vport,
  779.                 XtNverticalList, True,
  780.                 XtNforceColumns, True,
  781.                 XtNdefaultColumns, 1,
  782.                 XtNnumberStrings, 0,
  783.                 NULL);
  784.  
  785.     /*
  786.     **  The text area and buttons
  787.     */
  788.     form = XtVaCreateManagedWidget("form2",
  789.             formWidgetClass, pane,
  790.             XtNborderWidth, 0,
  791.             NULL);
  792.     form2 = XtVaCreateManagedWidget("subForm",
  793.             formWidgetClass, form,
  794.             XtNborderWidth, 0,
  795.             XtNtop, XtChainTop,
  796.             XtNbottom, XtChainTop,
  797.             NULL);
  798.  
  799.     selectLabel = XtVaCreateWidget("pointLabel",
  800.             labelWidgetClass, form2,
  801.             XtNborderWidth, 0,
  802.             XtNleft, XtChainLeft,
  803.             XtNright, XtChainLeft,
  804.             NULL);
  805.  
  806.     XtAppAddActions(XtWidgetToApplicationContext(form2), &pointAct, 1);
  807.  
  808.     arg->pointSelect = XtVaCreateWidget("pointSelect",
  809.             asciiTextWidgetClass, form2,
  810.             XtNleft, XtChainLeft,
  811.             XtNright, XtChainRight,
  812.             XtNfromHoriz, selectLabel,
  813.             XtNeditType, XawtextEdit,
  814.             XtNwrap, XawtextWrapNever,
  815.             XtNlength, 8,
  816.             XtNtranslations, 
  817.                 XtParseTranslationTable("#override\n\
  818.                     <Key>Return: point-size-ok()\n\
  819.                     <Key>Linefeed: point-size-ok()\n\
  820.                     Ctrl<Key>M: point-size-ok()\n\
  821.                     Ctrl<Key>J: point-size-ok()\n"),
  822.             NULL);
  823.  
  824.     label = XtVaCreateManagedWidget("fontNameLabel",
  825.             labelWidgetClass, form,
  826.             XtNborderWidth, 0,
  827.             XtNfromVert, form2,
  828.             XtNleft, XtChainLeft,
  829.             XtNtop, XtChainTop,
  830.             XtNbottom, XtChainTop,
  831.             NULL);
  832.     arg->fontName = XtVaCreateManagedWidget("fontName",
  833.             asciiTextWidgetClass, form,
  834.             XtNfromVert, form2,
  835.             XtNfromHoriz, label,
  836.             XtNallowResize, True,
  837.             XtNstring, "",
  838.             XtNtop, XtChainTop,
  839.             XtNbottom, XtChainTop,
  840.             XtNdisplayCaret, False,
  841.             NULL);
  842.  
  843.     arg->text = XtVaCreateManagedWidget("text",
  844.             asciiTextWidgetClass, form,
  845.             XtNfromVert, arg->fontName,
  846.             XtNallowResize, True,
  847.             XtNstring, "",
  848.             XtNtop, XtChainTop,
  849.             XtNbottom, XtChainBottom,
  850.             XtNdisplayCaret, False,
  851.             NULL);
  852.  
  853.     okButton = XtVaCreateManagedWidget("ok",
  854.             commandWidgetClass, form,
  855.             XtNfromVert, arg->text,
  856.             XtNtop, XtChainBottom,
  857.             XtNbottom, XtChainBottom,
  858.             XtNright, XtChainLeft,
  859.             XtNleft, XtChainLeft,
  860.             NULL);
  861.     applyButton = XtVaCreateManagedWidget("apply",
  862.             commandWidgetClass, form,
  863.             XtNfromVert, arg->text,
  864.             XtNfromHoriz, okButton,
  865.             XtNtop, XtChainBottom,
  866.             XtNbottom, XtChainBottom,
  867.             XtNright, XtChainLeft,
  868.             XtNleft, XtChainLeft,
  869.             NULL);
  870.  
  871.     doneButton = XtVaCreateManagedWidget("done",
  872.             commandWidgetClass, form,
  873.             XtNfromVert, arg->text,
  874.             XtNfromHoriz, applyButton,
  875.             XtNtop, XtChainBottom,
  876.             XtNbottom, XtChainBottom,
  877.             XtNleft, XtChainLeft,
  878.             XtNright, XtChainLeft,
  879.             XtNleft, XtChainLeft,
  880.             NULL);
  881.  
  882.     /*
  883.     **  Init the world
  884.     */
  885.     arg->paint = paint;
  886.     arg->namesStorage = XListFonts(XtDisplay(shell), "*", 32767, &arg->number),
  887.     arg->names = chop(&arg->number, arg->namesStorage);
  888.     arg->expectFlag = False;
  889.     match(arg);
  890.  
  891.     if (haveScalable) {
  892.         Widget    list[2];
  893.         list[0] = selectLabel;
  894.         list[1] = arg->pointSelect;
  895.         XtManageChildren(list, 2);
  896.     } else {
  897.         XtVaSetValues(form2, XtNwidth, 1, XtNheight, 1, NULL);
  898.     }
  899.  
  900.     XtAddEventHandler(arg->spacing, ButtonPressMask|ButtonReleaseMask, False, expectCallback, (XtPointer)arg);
  901.     XtAddEventHandler(arg->family, ButtonPressMask|ButtonReleaseMask, False, expectCallback, (XtPointer)arg);
  902.     XtAddEventHandler(arg->weight, ButtonPressMask|ButtonReleaseMask, False, expectCallback, (XtPointer)arg);
  903.     XtAddEventHandler(arg->point, ButtonPressMask|ButtonReleaseMask, False, expectCallback, (XtPointer)arg);
  904.  
  905.     XtAddCallback(arg->spacing, XtNcallback, listCallback, (XtPointer)arg);
  906.     XtAddCallback(arg->family, XtNcallback, listCallback, (XtPointer)arg);
  907.     XtAddCallback(arg->weight, XtNcallback, listCallback, (XtPointer)arg);
  908.     XtAddCallback(arg->point, XtNcallback, listCallback, (XtPointer)arg);
  909.  
  910.     XtAddCallback(okButton, XtNcallback, okCallback, (XtPointer)arg);
  911.     XtAddCallback(applyButton, XtNcallback, applyCallback, (XtPointer)arg);
  912.     XtAddCallback(doneButton, XtNcallback, closeCallback, (XtPointer)arg);
  913.     AddDestroyCallback(shell, 
  914.         (void (*)(Widget, void *, XEvent *))closeCallback, arg);
  915.     
  916.     XtPopup(shell, XtGrabNone);
  917.     StateSetBusyWatch(False);
  918.  
  919.     theArg = arg;
  920. }
  921.